24 research outputs found
Shrub-depth: Capturing Height of Dense Graphs
The recent increase of interest in the graph invariant called tree-depth and
in its applications in algorithms and logic on graphs led to a natural
question: is there an analogously useful "depth" notion also for dense graphs
(say; one which is stable under graph complementation)? To this end, in a 2012
conference paper, a new notion of shrub-depth has been introduced, such that it
is related to the established notion of clique-width in a similar way as
tree-depth is related to tree-width. Since then shrub-depth has been
successfully used in several research papers. Here we provide an in-depth
review of the definition and basic properties of shrub-depth, and we focus on
its logical aspects which turned out to be most useful. In particular, we use
shrub-depth to give a characterization of the lower levels of the
MSO1 transduction hierarchy of simple graphs
STANSE: Bug-finding Framework for C Programs
Regular paper accepted at the MEMICS 2011 workshop. The paper deals with static analysis. It also describes a framework and tool called Stanse
FO model checking of interval graphs
We study the computational complexity of the FO model checking problem on interval graphs, i.e., intersection graphs of intervals on the real line. The main positive result is that FO model checking and successor-invariant FO model checking can be solved in time O(n log n) for n-vertex interval graphs with representations containing only intervals with lengths from a prescribed finite set. We complement this result by showing that the same is not true if the lengths are restricted to any set that is dense in an open subset, e.g. in the set (1, 1 + ε)
Lower Bounds on the Complexity of MSO1 Model-Checking
One of the most important algorithmic meta-theorems is a famous result by
Courcelle, which states that any graph problem definable in monadic
second-order logic with edge-set quantifications (i.e., MSO2 model-checking) is
decidable in linear time on any class of graphs of bounded tree-width.
Recently, Kreutzer and Tazari proved a corresponding complexity lower-bound -
that MSO2 model-checking is not even in XP wrt. the formula size as parameter
for graph classes that are subgraph-closed and whose tree-width is
poly-logarithmically unbounded. Of course, this is not an unconditional result
but holds modulo a certain complexity-theoretic assumption, namely, the
Exponential Time Hypothesis (ETH).
In this paper we present a closely related result. We show that even MSO1
model-checking with a fixed set of vertex labels, but without edge-set
quantifications, is not in XP wrt. the formula size as parameter for graph
classes which are subgraph-closed and whose tree-width is poly-logarithmically
unbounded unless the non-uniform ETH fails. In comparison to Kreutzer and
Tazari; we use a stronger prerequisite, namely non-uniform instead of
uniform ETH, to avoid the effectiveness assumption and the construction of
certain obstructions used in their proofs; and we assume a different set
of problems to be efficiently decidable, namely MSO1-definable properties on
vertex labeled graphs instead of MSO2-definable properties on unlabeled graphs.
Our result has an interesting consequence in the realm of digraph width
measures: Strengthening the recent result, we show that no subdigraph-monotone
measure can be "algorithmically useful", unless it is within a poly-logarithmic
factor of undirected tree-width
The treewidth of smart contracts
Smart contracts are programs that are stored and executed on the Blockchain and can receive, manage and transfer money (cryptocurrency units). Two important problems regarding smart contracts are formal analysis and compiler optimization. Formal analysis is extremely important, because smart contracts hold funds worth billions of dollars and their code is immutable after deployment. Hence, an undetected bug can cause significant financial losses. Compiler optimization is also crucial, because every action of a smart contract has to be executed by every node in the Blockchain network. Therefore, optimizations in compiling smart contracts can lead to significant savings in computation, time and energy.
Two classical approaches in program analysis and compiler optimization are intraprocedural and interprocedural analysis. In intraprocedural analysis, each function is analyzed separately, while interprocedural analysis considers the entire program. In both cases, the analyses are usually reduced to graph problems over the control flow graph (CFG) of the program. These graph problems are often computationally expensive. Hence, there has been ample research on exploiting structural properties of CFGs for efficient algorithms. One such well-studied property is the treewidth, which is a measure of tree-likeness of graphs. It is known that intraprocedural CFGs of structured programs have treewidth at most 6, whereas the interprocedural treewidth cannot be bounded. This result has been used as a basis for many efficient intraprocedural analyses.
In this paper, we explore the idea of exploiting the treewidth of smart contracts for formal analysis and compiler optimization. First, similar to classical programs, we show that the intraprocedural treewidth of structured Solidity and Vyper smart contracts is at most 9. Second, for global analysis, we prove that the interprocedural treewidth of structured smart contracts is bounded by 10 and, in sharp contrast with classical programs, treewidth-based algorithms can be easily applied for interprocedural analysis. Finally, we supplement our theoretical results with experiments using a tool we implemented for computing treewidth of smart contracts and show that the treewidth is much lower in practice. We use 36,764 real-world Ethereum smart contracts as benchmarks and find that they have an average treewidth of at most 3.35 for the intraprocedural case and 3.65 for the interprocedural case
Qualitative Reachability in Stochastic BPA Games
We consider a class of infinite-state stochastic games generated by stateless
pushdown automata (or, equivalently, 1-exit recursive state machines), where
the winning objective is specified by a regular set of target configurations
and a qualitative probability constraint `>0' or `=1'. The goal of one player
is to maximize the probability of reaching the target set so that the
constraint is satisfied, while the other player aims at the opposite. We show
that the winner in such games can be determined in PTIME for the `>0'
constraint, and both in NP and coNP for the `=1' constraint. Further, we prove
that the winning regions for both players are regular, and we design algorithms
which compute the associated finite-state automata. Finally, we show that
winning strategies can be synthesized effectively.Comment: Submitted to Information and Computation. 48 pages, 3 figure